home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 May / macformat-024.iso / Shareware City / Developers / forth-to-latex-pretty-print / F2L / C source / Forth2LaTeX.c next >
Encoding:
C/C++ Source or Header  |  1995-01-05  |  25.4 KB  |  979 lines  |  [TEXT/KAHL]
  1. /*
  2.  
  3.         Forth2LaTeX  --  A Forth code pretty-printer for LaTeX
  4.         
  5.         
  6.         
  7.         (c) 1994, Ronald T. Kneusel, all rights reserved.
  8.         
  9.         Internet: kneusel@studsys.mscs.mu.edu
  10.         
  11.         
  12.   See the Forth2LaTeX manual for information about using this program.
  13.   This code is compatible with Unix, VMS, MS-DOS, and Macintosh computers.
  14.   
  15.   This code maybe distributed freely as long as all notices remain intact.
  16.   For profit distribution allowed only with the written consent of the 
  17.   author.
  18.   
  19.   Please pardon this messy and _very_ direct port from the Modula-2 original!
  20.   
  21.   
  22.   Last Mod:  01/05/95
  23.   
  24. */
  25.  
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <string.h>
  29. #include <ctype.h>
  30.  
  31. #define TRUE  1
  32. #define FALSE 0
  33.  
  34. #define last 32766         /* for use in string functions */
  35.  
  36. #define MAX  256           /* longest string */
  37.  
  38. /************************************************************************
  39.  
  40.      This code runs on Macintosh, MS-DOS, Unix, and VMS.  Simply define
  41.      the appropriate system below:
  42.      
  43. *************************************************************************/
  44.  
  45. #define MACINTOSH    /* choose one: MACINTOSH, VAX, UNIX, or MSDOS */
  46.  
  47. #ifdef MACINTOSH
  48. #include <console.h>
  49. #endif
  50.  
  51. /* Globals */
  52.  
  53. FILE  *f, *g, *w, *t;           /* file pointers */
  54.  
  55. int DONE,TOC,UP,INDEX,BOLD;     /* switches */
  56. int RA,QUOTE,SECTIONS;
  57. int COMMENTS,FIRST;
  58. int NOBRACKET;
  59.  
  60. struct tree         /* binary tree for defined word list */
  61. {
  62.     long int  line;          /* line number of definition */
  63.     char name[MAX];          /* name of defined word      */
  64.     struct tree *left;       /* left and right subtrees   */
  65.     struct tree *right;
  66. } ;
  67.  
  68. struct tree *root;              /* root of the tree */
  69.  
  70. char  infile[MAX], outfile[MAX];     /* source and dest file names */
  71.  
  72. /* if your compiler needs prototypes, include this file: */
  73.  
  74. #include "proto.c"
  75.  
  76.  
  77. /************************************************************************/
  78.  
  79.  
  80. main(int argc, char *argv[])
  81. { 
  82.  
  83. #ifdef MACINTOSH
  84.   argc = ccommand(&argv);
  85. #endif
  86.  
  87.   Header();
  88.   Init();
  89.  
  90.   root = NULL;
  91.  
  92.   switch(argc){
  93.     case 1: helpScreen(); 
  94.             break;
  95.     case 2: ShowSwitches();
  96.             ConvertFile(argv[1]); 
  97.             break;
  98.     default: setSwitches(argv[2]);
  99.              ShowSwitches();
  100.              ConvertFile(argv[1]);
  101.   }
  102.   
  103. #ifndef VAX 
  104.   return 0;
  105. #endif
  106. }
  107.  
  108. /*************************************************************************
  109.  
  110.      Functions - these are for the most part direct translations of the
  111.                  original Modula-2 functions, including the names
  112.                  
  113. *************************************************************************/
  114.  
  115. void helpScreen(void)
  116. {
  117.     printf("Quick help:\n\n");
  118.     printf("Command line:  Forth2LaTeX <infile> [<switch settings>]\n\n");
  119.     printf("Switches:  -xxx where presence of character 'x' is on\n\n");
  120.     printf("  u  -- uppercase code\n");
  121.     printf("  l  -- comments LATEX (default is FORTH)\n");
  122.     printf("  t  -- generate table of contents\n");
  123.     printf("  i  -- index of defined words\n");
  124.     printf("  b  -- bold colon definition names\n");
  125.     printf("  r  -- style is REPORT (default is ARTICLE)\n");
  126.     printf("\nExample: -ibr is INDEX, BOLD, and REPORT on, others off or ");
  127.     printf("default\n\n");
  128.     printf("See the manual for more information.\n\n");
  129.     printf("Author contact: kneusel@studsys.mscs.mu.edu\n\n");
  130. }
  131.  
  132. void Init(void)
  133. /* default settings */
  134. {
  135.    UP = FALSE;  COMMENTS = FALSE;  TOC = FALSE;
  136.    INDEX = FALSE; BOLD = FALSE;  RA = FALSE;
  137. }
  138.  
  139. void setSwitches(char *s)
  140. /* set the command line switches */
  141. {
  142.   int i;
  143.   
  144.   for(i=1;i<strlen(s);i++)
  145.     switch(up1(s[i])){
  146.        case 'U': UP       = TRUE;  break;
  147.        case 'L': COMMENTS = TRUE;  break;
  148.        case 'T': TOC      = TRUE;  break;
  149.        case 'I': INDEX    = TRUE;  break;
  150.        case 'B': BOLD     = TRUE;  break;
  151.        case 'R': RA       = TRUE;  break;
  152.        default : break; /* ignore */
  153.      }     
  154. }
  155.  
  156. void ShowSwitches(void)
  157. /* show the current switch settings */
  158. {
  159.   printf("Switches on: ");
  160.   if (UP) printf("UPPERCASE  ");
  161.   if (COMMENTS) printf("LATEX  ");
  162.   if (TOC) printf("TABLE-OF-CONTENTS  ");
  163.   if (INDEX) printf("INDEX  ");
  164.   if (BOLD) printf("BOLD  ");
  165.   if (RA) printf("REPORT"); 
  166.   printf("\n\n");  
  167. }
  168.  
  169. /*********************************************
  170.  *                                           *
  171.  *  C versions of Modula-2 string functions  *
  172.  *                                           *
  173.  *********************************************/
  174.  
  175. int Len(char *s)
  176. {  /* length of the string s */
  177.   return strlen(s);
  178. }
  179.  
  180. void Append(char *s1, char *s2)
  181. /* append s2 to s1 */
  182. {
  183.    s1 = strcat(s1,s2);
  184. }
  185.  
  186. void AppendCh(char *s, int c)
  187. /* append character c to s */
  188. {  
  189.    char nullstr[2];
  190.    
  191.    nullstr[1] = '\0';
  192.    nullstr[0] = c;
  193.    s = strcat(s,nullstr);
  194. }
  195.  
  196. int Equal(char *s1, char *s2)
  197. /* true if s1 == s2 */
  198. {
  199.   return ( strcmp(s1,s2) == 0 ) ? TRUE : FALSE; 
  200. }
  201.  
  202. void Copy(char *d, char *s, int st, int len)
  203. /* copy len chars from s into d starting at position st of s */
  204. {
  205.   if (st+len <= strlen(s)) {
  206.     strncpy(d,s+st,len);
  207.     d[len] = '\0'; 
  208.   } else {
  209.     strncpy(d,s+st,strlen(s)-st);
  210.     d[strlen(s)-st]='\0';
  211.   }
  212. }
  213.  
  214. int Same(char *s, int st, int len, char *t)
  215. /* is t the same as s from st length len? */
  216. {
  217.   if (st <= strlen(s))
  218.     return (strncmp(t,s+st,len) == 0) ? TRUE : FALSE;
  219. }
  220.  
  221. int Occurs(char *s, int st, char *t)
  222. /* does t occur in s starting at or after st? return index */
  223. {
  224.   int i;
  225.   
  226.   for(i=st; i<strlen(s); i++)
  227.   {
  228.     if (strncmp(s+i,t,strlen(t))==0)
  229.       return i;
  230.   }
  231.   return last;   /* no string will be larger than this */
  232. }
  233.  
  234. void Del(char *s,int st, int len)
  235. /* delete the len characters from s starting at st */
  236. {
  237.   int i,j,n;
  238.   
  239.   n = strlen(s);
  240.   if (st+len-1 >= n)  len = n - st;   /* keep in range */
  241.   
  242.   for(i=st, j=st+len; j<=n; i++, j++)
  243.     s[i] = s[j];
  244. }
  245.  
  246. /************************************************************/
  247.  
  248. void WriteTheString(FILE *f, char *s)     
  249. /* write a string to disk */
  250. {
  251.   fprintf(f,"%s\n",s);
  252. }
  253.  
  254. int ReadTheString(FILE *f, char *s)       
  255. /* read a string from disk */
  256. { int c,i;
  257.   i=0;
  258.   c=fgetc(f);
  259.   while ((c!=EOF) && (c!='\n')) {
  260.     s[i] = c;
  261.     i++;
  262.     c = fgetc(f);
  263.   }
  264.   s[i]='\0';
  265.   return (c == EOF) ? TRUE : FALSE;
  266. }
  267.  
  268. int up1(int c)
  269. /* make c uppercase */
  270. {  
  271.    return (c >= 'a' && c <= 'z') ? c+'A'-'a' : c;
  272. }
  273.  
  274. void Upper(char *s)       
  275. /* make s uppercase, ignores " " and \ ... */
  276. {
  277.   int i, quoted;
  278.   
  279.   quoted = FALSE;  i = 0;
  280.   while (i <= strlen(s))
  281.   {
  282.     if (s[i] == '\\') {
  283.       i = strlen(s)+10;
  284.     }
  285.     if (quoted == FALSE) {
  286.       s[i] = up1(s[i]);
  287.     }
  288.     if (s[i] == '"') {
  289.       quoted = (quoted == TRUE) ? FALSE : TRUE;
  290.     }
  291.     ++i;
  292.   }
  293. }
  294.  
  295. void Upper0(char *s)    
  296. /* make s uppercase, ignores nothing */
  297. {
  298.   int i;  
  299.   for(i=0;i<strlen(s);i++)
  300.     s[i] = up1(s[i]);
  301. }
  302.  
  303. void Dispose(struct tree *p)  
  304. /* Pascal "Dispose" */
  305. {
  306.   free(p);
  307. }
  308.  
  309. void Insert(struct tree *f, struct tree **r)
  310. /* insert a tree node */
  311. {
  312.   if (*r==NULL)
  313.     *r = f; 
  314.   else {
  315.     if (strcmp(f->name, (*r)->name) < 0 )
  316.       Insert(f, &(*r)->left);
  317.     else
  318.       Insert(f,&(*r)->right);
  319.   }
  320. }
  321.  
  322. void strclr(char *s)
  323. /* set the string s to the empty string */
  324. {
  325.   s[0] = '\0';
  326. }
  327.  
  328. void addName(char *s, long int line)
  329. /* add a name and line number to the tree */
  330. {
  331.   struct tree *p;
  332.   
  333.   if (root == NULL) {
  334.     root = (struct tree *) malloc(sizeof(struct tree));
  335.     if (root != NULL) {
  336.       strcpy(root->name,s);
  337.       root->line = line;
  338.       root->left = NULL;
  339.       root->right= NULL;
  340.     } else {
  341.       printf("Sorry, but there is not enough memory available.\n\n");
  342.       exit(1);
  343.     }
  344.   } else {
  345.     p = (struct tree *) malloc(sizeof(struct tree));
  346.     if (p != NULL) {
  347.       strcpy(p->name,s);
  348.       p->line = line;
  349.       p->left = NULL;
  350.       p->right= NULL;
  351.     } else {
  352.       printf("Sorry, but there is not enough memory available.\n\n");
  353.       exit(1);
  354.     }
  355.     Insert(p,&root);
  356.   }
  357. }
  358.  
  359. void StripSuffix(char *s, char *w)
  360. /* strips the file suffix if present */
  361. {
  362.   int i;
  363.   char t[MAX];
  364.   
  365.   strcpy(t,s);
  366.   Upper(t);
  367.   i = Occurs(t,0,".4TH");
  368.   if (i != last)
  369.     Copy(w,s,0,i);
  370.   else {
  371.     i = Occurs(t,0,".FORTH");
  372.     if (i != last)
  373.       Copy(w,s,0,i);
  374.     else {
  375.       i = Occurs(t,0,".FTH");
  376.       if (i != last) 
  377.         Copy(w,s,0,i);
  378.       else
  379.         strcpy(w,s);
  380.     }
  381.   }
  382. }
  383.  
  384. void Header(void)
  385. /* startup header */
  386. {
  387.   printf("\n\n");
  388.   printf("** Forth2LaTeX 1.9c **    ");
  389.   printf("Ronald T. Kneusel, 1994.  This program is freeware\n");
  390.   printf("--------------------------");
  391.   printf("--------------------------------------------------\n\n");
  392. }
  393.  
  394. void GetProgramInfo(void)
  395. /* get the title page info */
  396. {
  397.   int done,ok,n;
  398.   char str[MAX],prog[MAX],auth[MAX],start[MAX],
  399.        modif[MAX],modby[MAX],sum[MAX],t[MAX];
  400.   long int c;
  401.   
  402.   done = FALSE;
  403.   strclr(str); strclr(prog); strclr(auth); strclr(start);
  404.   strclr(modif); strclr(modby); strclr(sum); strclr(t);
  405.   c = 1;
  406.   done = ReadTheString(f,str);
  407.   while (!done)
  408.    {
  409.      if ((n=Occurs(str,0,"\\ Program:")) != last) {
  410.        Del(str,0,n+10); strcpy(prog,str); }
  411.      else if ((n=Occurs(str,0,"\\ Author:")) != last) {
  412.        Del(str,0,n+9);  strcpy(auth,str); }
  413.      else if ((n=Occurs(str,0,"\\ Started:")) != last) {
  414.        Del(str,0,n+10);  strcpy(start,str); }
  415.      else if ((n=Occurs(str,0,"\\ Modified:")) != last) {
  416.        Del(str,0,n+11);  strcpy(modif,str); }
  417.      else if ((n=Occurs(str,0,"\\ Modify By:")) != last) {
  418.        Del(str,0,n+12);  strcpy(modby,str); }
  419.      else if ((n=Occurs(str,0,"\\ Summary:")) != last) {
  420.        Del(str,0,n+10);  strcpy(sum,str); }
  421.      else if (Occurs(str,0,"\\ Comments:") != last) 
  422.        if (Occurs(str,0,"LATEX") != last)
  423.          COMMENTS = TRUE;
  424.        else if (Occurs(str,0,"FORTH") != last)
  425.          COMMENTS = FALSE;
  426.      else if (Occurs(str,0,"\\ Uppercase:") != last) 
  427.        if (Occurs(str,0,"ON") != last)
  428.          UP = TRUE;
  429.        else if (Occurs(str,0,"OFF") != last)
  430.          UP = FALSE;
  431.      else if (Occurs(str,0,"\\ Table of Contents:") != last) 
  432.        if (Occurs(str,0,"ON") != last)
  433.          TOC = TRUE;
  434.        else if (Occurs(str,0,"OFF") != last)
  435.          TOC = FALSE;
  436.      else if (Occurs(str,0,"\\ Index:") != last) 
  437.        if (Occurs(str,0,"ON") != last)
  438.          INDEX = TRUE;
  439.        else if (Occurs(str,0,"OFF") != last)
  440.          INDEX = FALSE;
  441.      else if (Occurs(str,0,"\\ Bold:") != last) 
  442.        if (Occurs(str,0,"ON") != last)
  443.          BOLD = TRUE;
  444.        else if (Occurs(str,0,"OFF") != last)
  445.          BOLD = FALSE;
  446.      else if (Occurs(str,0,"\\ Style:") != last) 
  447.        if (Occurs(str,0,"ON") != last)
  448.          RA = TRUE;
  449.        else if (Occurs(str,0,"OFF") != last)
  450.          RA = FALSE;
  451.      done = ReadTheString(f,str);
  452.      if ((Occurs(str,0,"ection:")==last) || (Occurs(str,0,"hapter:")==last))
  453.        ++c;
  454.    } /* while */
  455.    strcpy(str,"\\title{{\\bf ");  Append(str,prog);  Append(str,"}}");
  456.    WriteTheString(g,str);
  457.    strcpy(str,"\\author{{\\small "); Append(str,auth); Append(str,"}}");
  458.    WriteTheString(g,str);
  459.    WriteTheString(g,"\\date{{\\small \\today}}");
  460.    WriteTheString(g,"\\maketitle");
  461.    strcpy(str,"\\vspace{4in} \\hfil \\break {\\large{\\bf Program Information:}}");
  462.    Append(str," \\hfil \\break");
  463.    WriteTheString(g,str);
  464.    WriteTheString(g,"\\hfil \\break");
  465.    strcpy(str,"{\\bf Summary:}\\ \\ "); Append(str,sum);  Append(str,"\\hfil \\break");
  466.    WriteTheString(g,str);
  467.    strcpy(str,"{\\bf Author:}\\ \\ "); Append(str,auth); Append(str,"\\hfil \\break");
  468.    WriteTheString(g,str);
  469.    strcpy(str,"{\\bf Modified:}\\ \\ "); Append(str,modif); Append(str,"\\hfil \\break");
  470.    WriteTheString(g,str);
  471.    strcpy(str,"{\\bf Modify By:}\\ \\ "); Append(str,modby); Append(str,"\\hfil \\break");
  472.    WriteTheString(g,str);
  473.    sprintf(t,"%ld",c-1);
  474.    strcpy(str,"{\\bf Lines:}\\ \\ "); Append(str,t); Append(str,"\\hfil \\break \\clearpage");
  475.    WriteTheString(g,str);
  476. }  /* GetProgramInfo */
  477.  
  478. void CopyHeader(void)
  479. /* setup the document */
  480. {
  481.   char s[MAX];
  482.   
  483.   strcpy(s,"\\documentstyle[12pt]{");
  484.   if (RA)
  485.     Append(s,"report");
  486.   else
  487.     Append(s,"article");
  488.   Append(s,"}");
  489.   WriteTheString(g,s);
  490.   WriteTheString(g,"\\voffset=-0.8in");
  491.   WriteTheString(g,"\\hoffset=-0.5in");
  492.   WriteTheString(g,"\\textheight=9in");
  493.   WriteTheString(g,"\\textwidth=6.5in");
  494.   WriteTheString(g,"\\parindent=0pt");
  495.   WriteTheString(g,"\\begin{document}");
  496.   WriteTheString(g,"\\pagestyle{plain}");
  497.   WriteTheString(g,"\\pagenumbering{roman}");
  498. }
  499.  
  500. void HandleComment(int *i, char *str, char *out)
  501. /* process the comment portion of a line */
  502. {
  503.   int latex, q;
  504.   
  505.   Del(str,0,*i);    /* remove leading characters */
  506.   if (str[2]=='.') {  /* a \ . comment */
  507.     Del(str,0,3);
  508.     strcpy(out,str);
  509.     NOBRACKET = TRUE;
  510.   } else {
  511.     Append(out,"}{\\it");  latex = FALSE;
  512.     if (!COMMENTS) {
  513.       for(q=0;q<strlen(str);q++)
  514.        {
  515.          if (!latex) {
  516.            switch(str[q]){
  517.              case ' '  : Append(out,"\\ "); break;  /* convert special LaTeX */
  518.              case '_'  : Append(out,"\\_"); break;  /* characters            */
  519.              case '\11': Append(out,"\\ \\ \\ \\ "); break;
  520.              case '\\' : Append(out,"$\\backslash$"); break;
  521.              case '#'  : Append(out,"\\#"); break;
  522.              case '&'  : Append(out,"\\&"); break;
  523.              case '$'  : Append(out,"\\$"); break;
  524.              case '%'  : Append(out,"\\%"); break;
  525.              case '}'  : Append(out,"\\}"); break;
  526.              case '{'  : Append(out,"\\{"); break;
  527.              case '<'  : Append(out,"$<$"); break;
  528.              case '>'  : Append(out,"$>$"); break;
  529.              case '^'  : Append(out,"$\\uparrow$"); break;
  530.              case '`'  : latex = !latex;  break; /* LaTeX escape character */
  531.              case '~'  : Append(out,"$\\tilde{ }$"); break;
  532.            default:
  533.              AppendCh(out,str[q]);
  534.            }
  535.          } else {
  536.            if (str[q] != '`')
  537.              AppendCh(out,str[q]);
  538.            else
  539.              latex = !latex;
  540.          }
  541.        }
  542.       } else {
  543.         Append(out,str);
  544.       }
  545.     }
  546.     *i = last;  /* force loop to quit */
  547.  } /* HandleComment */
  548.  
  549. void HandleFunction(int *i, char *str, char *out, long int *c)
  550. /* process a colon definition */
  551. {
  552.    int q,old,s,k;
  553.    char name[MAX], t[MAX], w[MAX];
  554.  
  555.    if (((((*i>0) && (str[*i-1]==' ')) && (str[*i+1]==' ')) ||
  556.       ((*i==0) && (str[1]==' '))) && (!QUOTE)) {
  557.       if (BOLD || INDEX) {
  558.         old = *i;
  559.         ++(*i);
  560.         while ((*i<strlen(str)) && (str[*i]==' ')) 
  561.           ++(*i);
  562.         s = *i;
  563.         while ((*i<strlen(str)) && (str[*i]!=' '))
  564.           ++(*i);
  565.         Copy(w,str,s,*i-s);  /* word name */
  566.         if (UP) {
  567.           strcpy(t,w);
  568.           Upper(t);
  569.           strcpy(w,t);
  570.         }
  571.         strclr(name);
  572.         for(k=0;k<strlen(w);k++){
  573.           switch(w[k]){
  574.              case ' '  : Append(name,"\\ "); break;
  575.              case '_'  : Append(name,"\\_"); break; 
  576.              case '\11': Append(name,"\\ \\ \\ \\ "); break;
  577.              case '\\' : Append(name,"$\\backslash$"); break;
  578.              case '#'  : Append(name,"\\#"); break;
  579.              case '&'  : Append(name,"\\&"); break;
  580.              case '$'  : Append(name,"\\$"); break;
  581.              case '%'  : Append(name,"\\%"); break;
  582.              case '}'  : Append(name,"\\}"); break;
  583.              case '{'  : Append(name,"\\{"); break;
  584.              case '<'  : Append(name,"$<$"); break;
  585.              case '>'  : Append(name,"$>$"); break;
  586.              case '^'  : Append(name,"$\\uparrow$"); break;
  587.              case '~'  : Append(name,"$\\tilde{ }$"); break;
  588.            default:
  589.              AppendCh(name,w[k]);
  590.           }
  591.         }
  592.         addName(name,*c);   /* add to the tree */
  593.         if (BOLD) {
  594.           Append(out,":\\ {\\bf ");
  595.           Append(out,name);
  596.           Append(out,"}\\ ");
  597.         } else {
  598.           Append(out,":");
  599.           *i = old;
  600.         }
  601.       } else
  602.         Append(out,":");
  603.       } else
  604.         Append(out,":");
  605.  } /* HandleFunction */
  606.  
  607. void ProcessString(char *str, char *out, long int *c)
  608. /* process a single string character by character */
  609. {
  610.   char s[MAX];
  611.   int  i;
  612.   
  613.   NOBRACKET = FALSE;
  614.   strcpy(out,"\\leftline{{\\tt ");
  615.  
  616. #ifndef VAX
  617.   sprintf(s,"%5.5li",*c);
  618. #endif
  619.  
  620. #ifdef VAX
  621.   sprintf(s,"%5.5ld",*c);
  622.   for(i=0;i<strlen(s);i++)
  623.     if ( s[i]==' ' )
  624.       s[i]='0';
  625. #endif
  626.  
  627.   Append(out,s);  Append(out,"\\ -\\ ");
  628.   i = 0; QUOTE = FALSE;
  629.   while (i<strlen(str))
  630.    {
  631.      switch(str[i]){
  632.        case ' '  : Append(out,"\\ "); break;
  633.        case '_'  : Append(out,"\\_"); break;
  634.        case '\11': Append(out,"\\ \\ \\ \\ "); break;
  635.        case '\\' : HandleComment(&i,str,out); break;
  636.        case '#'  : Append(out,"\\#"); break;
  637.        case '&'  : Append(out,"\\&"); break;
  638.        case '$'  : Append(out,"\\$"); break;
  639.        case '%'  : Append(out,"\\%"); break;
  640.        case '}'  : Append(out,"\\}"); break;
  641.        case '{'  : Append(out,"\\{"); break;
  642.        case '~'  : Append(out,"$\\tilde{ }$"); break;
  643.        case '^'  : Append(out,"$\\uparrow$"); break;
  644.        case ':'  : HandleFunction(&i,str,out,c); break;
  645.        case '"'  : AppendCh(out,'"');  QUOTE = !QUOTE; break;
  646.      default:
  647.        if (str[i]>' ') {
  648.          if ((!UP) || (QUOTE))
  649.            AppendCh(out,str[i]);
  650.          else
  651.            AppendCh(out,up1(str[i]));
  652.        }
  653.      } /* switch */
  654.      i++;
  655.    } /* while */
  656.   if (!NOBRACKET) {
  657.     Append(out,"}}");
  658.     NOBRACKET = FALSE;
  659.   }
  660. } /* process string */
  661.  
  662.  
  663. void MoreProcessString( char *str, char *out, long int c)
  664. /* handle VARIABLE, and such... */
  665. {
  666.    char ucStr[MAX], s[MAX], name[MAX];
  667.    int  n,i,f,ff;
  668.    
  669.    if (Same(str,0,9,"\\leftline")) {
  670.      Del(str,strlen(str)-2,2);  /* remove }} */
  671.      Append(str,"\\ ");
  672.      strcpy(ucStr,str);
  673.      Upper0(ucStr);
  674.      strclr(out);
  675.      do {
  676.        f = FALSE;
  677.        i = Occurs(str,0,"{\\it$\\backslash");  /* position of any comment */
  678.  
  679.        if ((n=Occurs(ucStr,0," CREATE\\ ")) != last) {
  680.          n += 7;  f = TRUE; }
  681.        else if ((n=Occurs(ucStr,0," VARIABLE\\ ")) != last) {
  682.          n += 9;  f = TRUE; }
  683.        else if ((n=Occurs(ucStr,0," CONSTANT\\ ")) != last) {
  684.          n += 9;  f = TRUE; }
  685.        else if ((n=Occurs(ucStr,0," FVARIABLE\\ ")) != last) {
  686.          n += 10;  f = TRUE; }
  687.        else if ((n=Occurs(ucStr,0," FCONSTANT\\ ")) != last) {
  688.          n += 10;  f = TRUE; }
  689.          
  690.        if (n >= i)  f = FALSE;
  691.        if (f) {
  692.          Copy(s,str,0,n);  Append(out,s);
  693.          /* get name from str */
  694.          Del(str,0,n);  Del(ucStr,0,n);
  695.          do {
  696.            ff = FALSE;
  697.            if (Same(str,0,2,"\\ ")) {
  698.              Del(str,0,2);  Del(ucStr,0,2);
  699.              Append(out,"\\ ");
  700.              ff = TRUE;
  701.            }
  702.          } while( ff );
  703.          n = Occurs(str,0,"\\ ");
  704.          Copy(name,str,0,n);  /* get the name */
  705.          Append(out,"{\\sf ");
  706.          Append(out,name);
  707.          Append(out,"}");
  708.          Del(str,0,n);  Del(ucStr,0,n);
  709.          addName(name,c);  /* add name to list */
  710.        }
  711.      } while( f );
  712.      Append(out,str);
  713.      Del(out,strlen(out)-2,2);
  714.      Append(out,"}}");
  715.    } else {
  716.       strcpy(out,str);
  717.    }
  718. } /* MoreProcessString */
  719.  
  720. /* Globals for OutputIndex */
  721.  
  722. int lineCount,i;      /* number of lines, number of items on a line */
  723. char outt[MAX];       /* line to output */
  724.  
  725. void Display(struct tree *p)
  726. /* display tree data in LaTeX tabular environment */
  727. {
  728.    char t[MAX],w[MAX];
  729.    int  j;
  730.    
  731.    Append(outt,"{\\rm ");  Append(outt,p->name);  Append(outt,"}\\ {\\tt (");
  732.  
  733. #ifndef VAX
  734.   sprintf(w,"%5.5li",p->line);
  735. #endif
  736.  
  737. #ifdef VAX
  738.   sprintf(w,"%5.5ld",p->line);
  739.   for(j=0;j<strlen(w);j++)
  740.     if ( w[j]==' ' )
  741.       w[j]='0';
  742. #endif
  743.  
  744.    Append(outt,w);
  745.    if (i<2) {
  746.      Append(outt,")} & ");
  747.      i++;
  748.    } else {
  749.      i=0;
  750.      Append(outt,")} \\\\");
  751.      WriteTheString(g,outt);
  752.      strclr(outt);  lineCount++;
  753.      if (lineCount>35) {
  754.        WriteTheString(g,"\\end{tabular}");
  755.        WriteTheString(g,"\\clearpage");
  756.        WriteTheString(g,"\\begin{tabular}{lllll}");
  757.        lineCount = 0;
  758.      }
  759.    }
  760. } /* display */
  761.  
  762. void WalkTree(struct tree *p)
  763. /* Inorder traversal of name tree */
  764. {
  765.    if (p != NULL) {
  766.      WalkTree(p->left);
  767.      Display(p); 
  768.      WalkTree(p->right);
  769.    }
  770. } /* WalkTree */
  771.  
  772. void OutputIndex(void)
  773. /* print the index of names */
  774. {
  775.    int q;
  776.    
  777.    strclr(outt);  i = 0;  lineCount = 0;
  778.    if ( (!RA) || ((RA) && (!TOC)) ) {  /* article */
  779.      WriteTheString(g,"\\clearpage");
  780.      if (SECTIONS)
  781.        WriteTheString(g,"\\section{Index} \\vspace{0.5in}");
  782.      else
  783.        WriteTheString(g,"\\begin{center} {\\huge Index} \\end{center} \\vspace{0.5in}");
  784.      WriteTheString(g,"\\vspace{0.5in}");
  785.      WriteTheString(g,"\\hfil \\break");
  786.    } else {                            /* report */
  787.      WriteTheString(g,"\\appendix");
  788.      WriteTheString(g,"\\chapter{Index of User-Defined Names}");
  789.    }
  790.    WriteTheString(g,"\\begin{tabular}{lllll}");
  791.    WalkTree(root);
  792.    if (i != 0) {
  793.      for(q=1;q<=3-(i+1);q++)
  794.        Append(outt," & ");
  795.      Append(outt," \\\\");
  796.      WriteTheString(g,outt);
  797.    }
  798.    WriteTheString(g,"\\end{tabular}");
  799. } /* outputIndex */
  800.  
  801. void Convert(char *infile, long int *count)
  802. /* do the conversion */
  803. {
  804.    char str[MAX],out[MAX],date[MAX],time[MAX];
  805.    int  done,n;
  806.    
  807.    if (FIRST) {
  808.      CopyHeader();
  809.      GetProgramInfo();
  810.      if (TOC)
  811.        WriteTheString(g,"\\tableofcontents \\clearpage");
  812.      WriteTheString(g,"\\pagestyle{plain}");
  813.      WriteTheString(g,"\\pagenumbering{arabic}");
  814.      WriteTheString(g,"\\setcounter{page}{1}");
  815.      WriteTheString(g,"\\small");
  816.      fclose(f);
  817.      FIRST = FALSE;
  818.      f = fopen(infile,"r");
  819.      *count = 0;
  820.    }
  821.    done = FALSE;
  822.    done = ReadTheString(f,str);
  823.    strclr(out);
  824.    while (!done) {
  825.      if ( ((n=Occurs(str,0,"\\ Section:")) != last) && (TOC) ) {
  826.        Del(str,0,n+10);
  827.        strcpy(out,"\\section{"); Append(out,str);  Append(out,"}");
  828.        SECTIONS = TRUE; }
  829.      else if ( ((n=Occurs(str,0,"\\ Subsection:")) != last) && (TOC) ) {
  830.        Del(str,0,n+13);
  831.        strcpy(out,"\\subsection{"); Append(out,str);  Append(out,"}");
  832.        SECTIONS = TRUE; }
  833.      else if ( ((n=Occurs(str,0,"\\ Subsubection:")) != last) && (TOC) ) {
  834.        Del(str,0,n+16);
  835.        strcpy(out,"\\subsubsection{"); Append(out,str);  Append(out,"}");
  836.        SECTIONS = TRUE; }
  837.      else if (Same(str,0,8,"\\ latex:")) {
  838.        Del(str,0,8);  WriteTheString(g,str); }  /* \ latex: form */
  839.      else if ( (RA) && (TOC) && ((n=Occurs(str,0,"\\ Chapter:"))!=last) ) {
  840.        Del(str,0,n+10);
  841.        strcpy(out,"\\chapter{"); Append(out,str);  Append(out,"}"); }
  842.      else {
  843.        ProcessString(str,out,count);
  844.        strcpy(str,out);
  845.        MoreProcessString(str,out,*count);
  846.        (*count)++;
  847.      }
  848.      WriteTheString(g,out);
  849.      out[0]='\0'; str[0]='\0';
  850.      done = ReadTheString(f,str);
  851.    } /* while */
  852. } /* convert */
  853.  
  854. void KillTree(struct tree *p)
  855. /* kill the old tree */
  856. {
  857.    if (p != NULL) {
  858.      KillTree(p->left);
  859.      KillTree(p->right);
  860.      Dispose(p);
  861.    }
  862. } /* KillTree */
  863.  
  864. void UpdateCount(char *c, char *outfile)
  865. /* Kludge to update the count when using multiple files */
  866. {
  867.    int done;
  868.    char str[MAX],*t;
  869.    
  870.    done = FALSE;
  871.    f = fopen(outfile,"r");
  872.    t = "dpp6113909294.tmp";
  873.    g = fopen(t,"w");
  874.    done = ReadTheString(f,str);
  875.    while (!done) {
  876.      if (Occurs(str,0,"{\\bf Lines:}") != last) {
  877.        strcpy(str,"{\\bf Lines:}\\ \\ "); Append(str,c);
  878.        Append(str," \\hfil \\break \\clearpage");
  879.      }
  880.      WriteTheString(g,str);
  881.      done = ReadTheString(f,str);
  882.    }
  883.    fclose(f);
  884.    fclose(g);
  885.    f = fopen(t,"r");
  886.    g = fopen(outfile,"w");
  887.    done = FALSE;
  888.    done = ReadTheString(f,str);
  889.    while (!done) {
  890.      WriteTheString(g,str);
  891.      done = ReadTheString(f,str);
  892.    }
  893.    fclose(f);  fclose(g);
  894.    remove(t);
  895. }
  896.  
  897. void CommandFile(char *cmdfile)
  898. /* process a .f2l command file */
  899. {
  900.    int  done,skip,b,n,i;
  901.    char str[MAX],outfile[MAX],infile[MAX],t[MAX];
  902.    long int c;
  903.    
  904.    printf("Command file: %s\n\n",cmdfile);
  905.    w = fopen(cmdfile,"r");
  906.    done = FALSE;
  907.    strcpy(outfile,"a.tex");
  908.    done = ReadTheString(w,str);
  909.    while (!done) {
  910.      if ((n=Occurs(str,0,"# Output: "))!=last) {
  911.        Del(str,0,n+10);
  912.        done = TRUE;
  913.        strcpy(outfile,str);
  914.      }
  915.      done = ReadTheString(w,str);
  916.    }
  917.    fclose(w);
  918.    g = fopen(outfile,"w");
  919.    printf("Output file : %s\n\nProcessing file...\n\n",outfile);
  920.    w = fopen(cmdfile,"r");
  921.    c = 0;
  922.    done = FALSE;  FIRST = TRUE;
  923.    done = ReadTheString(w,str);
  924.    while (!done) {
  925.      skip = FALSE;  
  926.      infile[0]='\0';
  927.      if ( str[0]!='\0' ) {
  928.        n = 0;
  929.        while( (str[n]==' ') || (str[n]=='\11') )
  930.          n++;
  931.        for(i=n;i<strlen(str);i++)
  932.          if ( (str[i]!='#') && (!skip) && (str[i]!=' ') )
  933.            AppendCh(infile,str[i]);
  934.          else
  935.            skip = TRUE;
  936.      }
  937.      if (!Equal(infile,"")) {  /* process this file */
  938.        f = fopen(infile,"r");
  939.        printf("      %s\n",infile);
  940.        Convert(infile,&c);
  941.        fclose(f);
  942.      }
  943.      done = ReadTheString(w,str);
  944.    }
  945.    if (INDEX)  OutputIndex();
  946.    WriteTheString(g,"\\end{document}");
  947.    fclose(g);  fclose(w);
  948.    sprintf(t,"%ld",c-1);
  949.    UpdateCount(t,outfile);
  950.    printf("\n\n%s lines total.\n\n",t);
  951. } /* CommandFile */
  952.  
  953. void ConvertFile(char *infile)
  954. /* handle the source and dest files and convert */
  955. {
  956.    char t[MAX],outfile[MAX];  long int c;
  957.    
  958.    if ( (Occurs(infile,0,".f2l")!=last) || (Occurs(infile,0,".F2L")!=last) )
  959.      CommandFile(infile);
  960.    else {
  961.      StripSuffix(infile,outfile);
  962.      Append(outfile,".tex");
  963.      printf("\nStarting conversion...\n\n");
  964.      g = fopen(outfile,"w");
  965.      FIRST = TRUE;
  966.      f = fopen(infile,"r");
  967.      Convert(infile,&c);
  968.      if (INDEX)
  969.        OutputIndex();
  970.      fclose(f);
  971.      WriteTheString(g,"\\end{document}");
  972.      fclose(g);
  973.      printf("Conversion complete, %ld lines.\n\n",c);
  974.    }
  975.    KillTree(root);
  976.    root = NULL;
  977. } /* ConvertFile */
  978.  
  979.